int __bits(8) mas[20];
int __bits(8) res[20];
int __bits(8) min_val;
int __bits(8) max_val;
int __bits(8) count;

void main() {
count = 20;

for (int i = 0; i < 20; i++) {
res[i] = 0;
}

for (i = 0; i < 10; i++) {
min_val = 255;
max_val = 0;

for (int j = 0; j < count; j++) {
if (mas[j] < min_val) {
min_val = mas[j];
}
if (mas[j] > max_val) {
max_val = mas[j];
}
}

res[2 * i] = min_val;
res[2 * i + 1] = max_val;

for ( j = 0; j < count; j++) {
if (mas[j] == min_val || mas[j] == max_val) {
mas[j] = 256;
}
}

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];
int __bits(8) min_index, max_index;
int __bits(8) count;

void main() {
for (count = 0; count < 10; count++) {
int __bits(8) min_val = 255, max_val = 0;

for (int i = 0; i < 20 - count * 2; i++) {
if (mas[i] < min_val) { min_val = mas[i]; min_index = i; }
if (mas[i] > max_val) { max_val = mas[i]; max_index = i; }
}

res[count * 2] = min_val;
res[count * 2 + 1] = max_val;

mas[min_index] = 255;
if (max_index == min_index) {
max_index = (min_index + 1) % (20 - count * 2);
while (mas[max_index] == 255) max_index = (max_index + 1) % (20 - count * 2);
}
mas[max_index] = 0;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) min_arr[10];
int __bits(8) max_arr[10];
int __bits(8) res[20];
int __bits(8) min_val;
int __bits(8) max_val;
int __bits(8) min_index;
int __bits(8) max_index;
int __bits(8) count;
int __bits(8) remaining;

void main() {
remaining = 20;

for (count = 0; count < 10; count++) {
min_val = 255;
max_val = 0;
min_index = -1;
max_index = -1;

for (int i = 0; i < remaining; i++) {
if (mas[i] < min_val) {
min_val = mas[i];
min_index = i;
}
if (mas[i] > max_val) {
max_val = mas[i];
max_index = i;
}
}

min_arr[count] = min_val;
if (count < 9) {
max_arr[count] = max_val;
}

mas[min_index] = 255;
if (max_index == min_index) {
max_index = (max_index + 1) % remaining;
while (mas[max_index] == 255) {
max_index = (max_index + 1) % remaining;
}
}
mas[max_index] = 0;

remaining -= 2;
}

for (count = 0; count < 10; count++) {
res[2 * count] = min_arr[count];
res[2 * count + 1] = max_arr[count];
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];
int __bits(8) min_val;
int __bits(8) max_val;
int __bits(8) min_index;
int __bits(8) max_index;
int __bits(8) count;
int __bits(8) i;
int __bits(8) remaining;

void main() {
remaining = 20;

for (count = 0; count < 20; count++) {
min_val = 255;
max_val = 0;
min_index = -1;
max_index = -1;

for (i = 0; i < remaining; i++) {
if (mas[i] < min_val) {
min_val = mas[i];
min_index = i;
}
if (mas[i] > max_val) {
max_val = mas[i];
max_index = i;
}
}

res[count] = min_val;
count++;

if (count < 20) {
res[count] = max_val;
count++;
}

mas[min_index] = 255;
if (max_index == min_index) {
max_index = (max_index + 1) % remaining;
while (mas[max_index] == 255) {
max_index = (max_index + 1) % remaining;
}
}
mas[max_index] = 0;

remaining -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];
int __bits(8) count;

void main() {
for (count = 0; count < 20; count++) {
int __bits(8) min_val = 255;
int __bits(8) max_val = 0;
int __bits(8) min_index = -1;
int __bits(8) max_index = -1;
int __bits(8) i;

for (i = 0; i < 20 - count; i++) {
if (mas[i] < min_val) {
min_val = mas[i];
min_index = i;
}
if (mas[i] > max_val) {
max_val = mas[i];
max_index = i;
}
}

res[count] = min_val;
count++;

if (count < 20) {
res[count] = max_val;
count++;
}

mas[min_index] = 255;
if (max_index == min_index) {
max_index = (min_index + 1) % (20 - count);
}
mas[max_index] = 0;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];
int __bits(8) min_val;
int __bits(8) max_val;
int __bits(8) count;

void main() {
for (count = 0; count < 20; count++) {
int __bits(8) current_min_index = 0;
int __bits(8) current_max_index = 0;
int __bits(8) i;

min_val = 255;
max_val = 0;

for (i = 0; i < 20 - count; i++) {
if (mas[i] < min_val) {
min_val = mas[i];
current_min_index = i;
}
if (mas[i] > max_val) {
max_val = mas[i];
current_max_index = i;
}
}

res[count] = min_val;
count++;

if (count < 20) {
res[count] = max_val;
count++;
}

mas[current_min_index] = 255;
mas[current_max_index] = 0;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int sorted[20];
for (int i = 0; i < 20; i++) {
sorted[i] = mas[i];
}

for (int i = 0; i < 19; i++) {
for (int j = 0; j < 19 - i; j++) {
if (sorted[j] > sorted[j + 1]) {
int temp = sorted[j];
sorted[j] = sorted[j + 1];
sorted[j + 1] = temp;
}
}
}

int left = 0, right = 19;
for (int i = 0; i < 10; i++) {
res[2 * i] = sorted[left++];
res[2 * i + 1] = sorted[right--];
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) i, j, temp;

for (i = 0; i < 19; i++) {
for (j = i + 1; j < 20; j++) {
if (mas[i] < mas[j]) {
temp = mas[i];
mas[i] = mas[j];
mas[j] = temp;
}
}
}

int __bits(8) left = 0;
int __bits(8) right = 19;
for (i = 0; i < 20; i++) {
if (i % 2 == 0) {
res[i] = mas[right];
right--;
i++;
} else {
res[i] = mas[left];
left++;
}
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];
int __bits(8) temp_min[10];
int __bits(8) temp_max[10];

void main() {
int __bits(8) i, j, k, remaining_count = 20;
int __bits(8) min_idx, max_idx;

for (i = 0; i < 20; i++) {
res[i] = 0;
}

for (i = 0; remaining_count > 0; i++) {
int __bits(8) min_val = 127;
int __bits(8) max_val = -128;

min_idx = -1;
max_idx = -1;

for (j = 0; j < 20; j++) {
if (j < remaining_count && mas[j] < min_val) {
min_val = mas[j];
min_idx = j;
}
}

for (j = 0; j < 20; j++) {
if (j < remaining_count && mas[j] > max_val) {
max_val = mas[j];
max_idx = j;
}
}

temp_min[i] = min_val;
if (remaining_count > 1) {
temp_max[i] = max_val;
}

remaining_count -= 2;

mas[min_idx] = 128;
if (max_idx == min_idx) {
max_idx = (min_idx + 1) % 20;
}
mas[max_idx] = 128;
}

for (i = 0, j = 0; i < 10; i++, j += 2) {
res[j] = temp_min[i];
res[j + 1] = temp_max[i];
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) min_idx, max_idx, i, j;
int __bits(8) min_val, max_val;
int __bits(8) remaining_count = 20;

for (i = 0; i < 20; i++) {
res[i] = 0;
}

for (i = 0, j = 0; remaining_count > 0; i++, j++) {
min_val = 127;
max_val = -128;
min_idx = -1;
max_idx = -1;

for (int k = 0; k < remaining_count; k++) {
if (mas[k] < min_val) {
min_val = mas[k];
min_idx = k;
}
if (mas[k] > max_val) {
max_val = mas[k];
max_idx = k;
}
}

res[j] = min_val;
j++;
if (remaining_count > 1) {
res[j] = max_val;
}

mas[min_idx] = 128;
if (max_idx == min_idx) {
max_idx = (min_idx + 1) % remaining_count;
}
mas[max_idx] = 128;

remaining_count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20] = {5, 1, 4, 2, 7, 1, 3, 5, 9, 8, 1, 6, 9, 4, 12, 3, 1, 5, 7, 19};
int __bits(8) res[20];
int __bits(8) min_values[10];
int __bits(8) max_values[10];
int __bits(8) count = 20;
int __bits(8) min_index;
int __bits(8) max_index;
int __bits(8) min_count = 0;
int __bits(8) max_count = 0;
int __bits(8) i;

void main() {
while (count > 0) {
min_index = 0;
for (i = 1; i < count; i++) {
if (mas[i] < mas[min_index]) {
min_index = i;
}
}
min_values[min_count++] = mas[min_index];

for (i = min_index; i < count - 1; i++) {
mas[i] = mas[i + 1];
}
count--;

if (count > 0) {
max_index = 0;
for (i = 1; i < count; i++) {
if (mas[i] > mas[max_index]) {
max_index = i;
}
}
max_values[max_count++] = mas[max_index];

for (i = max_index; i < count - 1; i++) {
mas[i] = mas[i + 1];
}
count--;
}
}

for (i = 0; i < min_count; i++) {
res[i * 2] = min_values[i];
res[i * 2 + 1] = max_values[i];
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];
int __bits(8) min_values[10];
int __bits(8) max_values[10];

void main() {
int count = 20;
int min_index, max_index;
int min_count = 0, max_count = 0;

while (count > 0) {
min_index = 0;
for (int i = 1; i < count; i++) {
if (mas[i] < mas[min_index]) {
min_index = i;
}
}
min_values[min_count++] = mas[min_index];

for (i = min_index; i < count - 1; i++) {
mas[i] = mas[i + 1];
}
count--;

max_index = 0;
for (i = 1; i < count; i++) {
if (mas[i] > mas[max_index]) {
max_index = i;
}
}
max_values[max_count++] = mas[max_index];

for (i = max_index; i < count - 1; i++) {
mas[i] = mas[i + 1];
}
count--;
}

for (int i = 0; i < min_count; i++) {
res[i * 2] = min_values[i];
res[i * 2 + 1] = max_values[i];
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) min_index;
int __bits(8) max_index;
int __bits(8) min_value;
int __bits(8) max_value;
int __bits(8) count = 20;

for (int i = 0; i < 20; i++) {
res[i] = 0;
}

for (i = 0; i < 10; i++) {
min_value = 127;
max_value = -128;
min_index = -1;
max_index = -1;

for (int k = 0; k < count; k++) {
if (mas[k] < min_value) {
min_value = mas[k];
min_index = k;
}
}

for (k = 0; k < count; k++) {
if (mas[k] > max_value) {
max_value = mas[k];
max_index = k;
}
}

res[i * 2] = min_value;
res[i * 2 + 1] = max_value;

if (min_index > max_index) {
for (int k = min_index; k < count - 1; k++) {
mas[k] = mas[k + 1];
}
count--;
max_index--;
}

for (k = max_index; k < count - 1; k++) {
mas[k] = mas[k + 1];
}
count--;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) min_index, max_index;
int __bits(8) min_value, max_value;
int __bits(8) remaining[20];
int __bits(8) count = 20;
int i, j;
for (i = 0; i < 20; i++) {
remaining[i] = mas[i];
}

for (i = 0, j = 0; i < 10; i++, j += 2) {
min_value = 127;
max_value = -128;

for (int k = 0; k < count; k++) {
if (remaining[k] < min_value) {
min_value = remaining[k];
min_index = k;
}
if (remaining[k] > max_value) {
max_value = remaining[k];
max_index = k;
}
}

res[j] = min_value;
remaining[min_index] = 128;
count--;

res[j + 1] = max_value;
remaining[max_index] = 128;
count--;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) min_index, max_index;
int __bits(8) min_value, max_value;
int __bits(8) remaining[20];
int __bits(8) count = 20;

for (int i = 0; i < 20; i++) {
remaining[i] = mas[i];
}

for (int i = 0, j = 0; i < 10; i++, j += 2) {
min_value = 127;
max_value = -128;

for (int k = 0; k < count; k++) {
if (remaining[k] < min_value) {
min_value = remaining[k];
min_index = k;
}
if (remaining[k] > max_value) {
max_value = remaining[k];
max_index = k;
}
}

res[j] = min_value;
remaining[min_index] = 128;
count--;

res[j + 1] = max_value;
remaining[max_index] = 128;
count--;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) min_index, max_index;
int __bits(8) min_value, max_value;
int __bits(8) remaining[20];
int __bits(8) count = 20;

for (int i = 0; i < 20; i++) {
remaining[i] = mas[i];
}

for (int i = 0, j = 0; i < 10; i++, j += 2) {
min_value = 127;
max_value = -128;

for (int k = 0; k < count; k++) {
if (remaining[k] < min_value) {
min_value = remaining[k];
min_index = k;
}
if (remaining[k] > max_value) {
max_value = remaining[k];
max_index = k;
}
}

res[j] = min_value;
remaining[min_index] = 128;
count--;

res[j + 1] = max_value;
remaining[max_index] = 128;
count--;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) temp[20];
int count = 20;

for (int i = 0; i < 20; i++) {
temp[i] = mas[i];
}

for ( i = 0; i < 10; i++) {
int min_index = 0;
int max_index = 0;
int min_value = 127;
int max_value = -128;

for (int j = 0; j < count; j++) {
if (temp[j] < min_value) {
min_value = temp[j];
min_index = j;
}
if (temp[j] > max_value) {
max_value = temp[j];
max_index = j;
}
}

res[2 * i] = min_value;
res[2 * i + 1] = max_value;

temp[min_index] = 128;
temp[max_index] = 128;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) temp[20];
int count = 20;

for (int i = 0; i < 20; i++) {
temp[i] = mas[i];
}

for (int i = 0; i < 10; i++) {
int min_index = 0;
int max_index = 0;
int min_value = 127;
int max_value = -128;

for (int j = 0; j < count; j++) {
if (temp[j] < min_value) {
min_value = temp[j];
min_index = j;
}
if (temp[j] > max_value) {
max_value = temp[j];
max_index = j;
}
}

res[2 * i] = min_value;
res[2 * i + 1] = max_value;

temp[min_index] = 128;
temp[max_index] = 128;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) used[20] = {0};
int count = 20;

for (int i = 0; i < 10; i++) {
int minIndex = -1;
int maxIndex = -1;

for (int j = 0; j < count; j++) {
if (!used[j]) {
if (minIndex == -1 || mas[j] < mas[minIndex]) {
minIndex = j;
}
if (maxIndex == -1 || mas[j] > mas[maxIndex]) {
maxIndex = j;
}
}
}

res[2 * i] = mas[minIndex];
res[2 * i + 1] = mas[maxIndex];

used[minIndex] = 1;
used[maxIndex] = 1;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) used[20] = {0};
int count = 20;

for (int i = 0; i < 10; i++) {
int minIndex = -1;
int maxIndex = -1;

for (int j = 0; j < count; j++) {
if (!used[j] && (minIndex == -1 || mas[j] < mas[minIndex])) {
minIndex = j;
}
}

for (int j = 0; j < count; j++) {
if (!used[j] && (maxIndex == -1 || mas[j] > mas[maxIndex])) {
maxIndex = j;
}
}

res[2 * i] = mas[minIndex];
res[2 * i + 1] = mas[maxIndex];

used[minIndex] = 1;
used[maxIndex] = 1;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) used[20] = {0};
int count = 20;

for (int i = 0; i < 10; i++) {
int minIndex = -1;
int maxIndex = -1;

for (int j = 0; j < count; j++) {
if (!used[j]) {
if (minIndex == -1 || mas[j] < mas[minIndex]) {
minIndex = j;
}
if (maxIndex == -1 || mas[j] > mas[maxIndex]) {
maxIndex = j;
}
}
}

res[2 * i] = mas[minIndex];
res[2 * i + 1] = mas[maxIndex];

used[minIndex] = 1;
used[maxIndex] = 1;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) used[20] = {0};
int count = 20;

for (int i = 0; i < 10; i++) {
int minIndex = -1;
int maxIndex = -1;

for (int j = 0; j < count; j++) {
if (!used[j]) {
if (minIndex == -1 || mas[j] < mas[minIndex]) {
minIndex = j;
}
if (maxIndex == -1 || mas[j] > mas[maxIndex]) {
maxIndex = j;
}
}
}

res[2 * i] = mas[minIndex];
res[2 * i + 1] = mas[maxIndex];

used[minIndex] = 1;
used[maxIndex] = 1;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int mas[20] = (5,1,4,2,7,1,3,5,9,8,1,6,9,4,12,3,1,5,7,19);
int res[20];

int main() {
int A[20];
int i, j, el;
for (i = 0; i < 20 ;i++) {
A[i] = mas[i];
}
for (i = 0; i < 20; i++) {
for (j = 0; j < 19; j++) {
if(A[j] > A[j+1]) {
el = A[j];
A[j] = A[j+1];
A[j+1] = el;
}
}
}
for (i = 0; i < 20; i += 2) {
res[i] = A[i];
res[i+1] = A[10+i];
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int min_val, max_val, min_index, max_index;

for (int i = 0; i < 20; i += 2) {
min_val = 127;
max_val = -128;
for (int j = i; j < i + 2; j++) {
if (mas[j] < min_val) {
min_val = mas[j];
min_index = j;
}

if (mas[j] > max_val) {
max_val = mas[j];
max_index = j;
}
}

res[i] = min_val;
res[i + 1] = max_val;
int tmp = mas[i];
mas[i] = mas[min_index];
mas[min_index] = tmp;

tmp = mas[i + 1];
mas[i + 1] = mas[max_index];
mas[max_index] = tmp;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

int main(){

for (int k =0; k<20; k++){
int min = mas[k];
int max = mas[k];
for (int i = k; i<20; i++){
if (mas[i] < min) min = mas[i];
}
for (i = k; i<20; i++){
if (mas[i] > max) max = mas[i];
}
res[i] = min;
res[i+1] = max;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

int main(){

for (int i =0; i<19; i++){
int min = mas[i];
int max = mas[i];
for (i; i<20; i++){
if (mas[i] < min) min = mas[i];
}
for (i; i<20; i++){
if (mas[i] > max) max = mas[i];
}
res[i] = min;
res[i+1] = max;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int min, max;
int minIndex, maxIndex;
int count = 20;
int i, j;

for (i = 0; i < 20; i++) {
res[i] = 0;
}

for (i = 0; i < 10; i++) {
minIndex = -1;
maxIndex = -1;
min = 255;
max = -1;

for (j = 0; j < count; j++) {
if (mas[j] < min) {
min = mas[j];
minIndex = j;
}
if (mas[j] > max) {
max = mas[j];
maxIndex = j;
}
}

res[2 * i] = min;
if (maxIndex == minIndex) {
max = -1;
for (j = 0; j < count; j++) {
if (j != minIndex && mas[j] > max) {
max = mas[j];
maxIndex = j;
}
}
}
res[2 * i + 1] = max;

mas[minIndex] = 255;
mas[maxIndex] = -1;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) min, max;
int __bits(8) minIndex, maxIndex;
int count = 20;
int i, j;

for (i = 0; i < 20; i++) {
res[i] = 0;
}

for (i = 0; i < 10; i++) {
minIndex = -1;
maxIndex = -1;
min = 255;
max = -1;

for (j = 0; j < count; j++) {
if (mas[j] < min) {
min = mas[j];
minIndex = j;
}
if (mas[j] > max) {
max = mas[j];
maxIndex = j;
}
}

res[2 * i] = min;
if (maxIndex == minIndex) {
max = -1;
for (j = 0; j < count; j++) {
if (j != minIndex && mas[j] > max) {
max = mas[j];
maxIndex = j;
}
}
}
res[2 * i + 1] = max;

mas[minIndex] = 255;
mas[maxIndex] = -1;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int __bits(8) min, max;
int __bits(8) minIndex, maxIndex;
int count = 20;

for (int i = 0; i < 20; i++) {
res[i] = 0;
}

for (int i = 0; i < 10; i++) {
minIndex = -1;
maxIndex = -1;
min = 255;
max = -1;

for (int j = 0; j < count; j++) {
if (mas[j] < min) {
min = mas[j];
minIndex = j;
}
if (mas[j] > max) {
max = mas[j];
maxIndex = j;
}
}

res[2 * i] = min;
if (maxIndex == minIndex) {
max = -1;
for (int j = 0; j < count; j++) {
if (j != minIndex && mas[j] > max) {
max = mas[j];
maxIndex = j;
}
}
}
res[2 * i + 1] = max;

mas[minIndex] = 255;
mas[maxIndex] = -1;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int count = 20;
int minIndex, maxIndex;

for (int i = 0; i < 10; i++) {
minIndex = 0;
maxIndex = 0;

for (int j = 1; j < count; j++) {
if (mas[j] < mas[minIndex]) {
minIndex = j;
}
if (mas[j] > mas[maxIndex]) {
maxIndex = j;
}
}

res[2 * i] = mas[minIndex];
if (maxIndex == minIndex) {
maxIndex = (minIndex + 1) % count;
}
res[2 * i + 1] = mas[maxIndex];

mas[minIndex] = 256;
mas[maxIndex] = 256;

count -= 2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main() {
int count = 20;
int minIndex, maxIndex;

for (int i = 0; i < 10; i++) {
minIndex = 0;
maxIndex = 0;

for (int j = 1; j < count; j++) {
if (mas[j] < mas[minIndex]) {
minIndex = j;
}
if (mas[j] > mas[maxIndex]) {
maxIndex = j;
}
}

res[2 * i] = mas[minIndex];
if (maxIndex == minIndex) {
maxIndex = (minIndex + 1) % count;
}
res[2 * i + 1] = mas[maxIndex];

mas[minIndex] = 256;
mas[maxIndex] = 256;

count -= 2;
}
}

------------------------------------------------------------
---------------------
char mas[20] = {5,1,4,2,7,1,3,5,9,8,1,6,9,4,12,3,1,5,7,19};
char res[20];

void main(){

int max = mas[0];
int min = mas[0];
for (int i = 0; i < 20; i++){
if (mas[i]> max) max = mas[i];
else if (mas[i] < min) min = mas[i];

}
res[i] = mas[max],mas[min];
}

------------------------------------------------------------
---------------------
int __bits(8)mas[20];
int __bits(8)res[20];


main(){
int start = 0;
int __bits(8)array[20];
for(int i=0;i<20;i++){
array[i] = mas[i];
}
while(start != 20){
int min = array[start];
int max= array[start];
int posmin = 0;
int posmax = 0;
for(int i=start+1;i<20;i++){
if(array[i]<min){
min = mas[i];
posmin = i;
}
if(array[i]>max){
max = mas[i];
posmax = i;
}
}
res[start] = min;
res[start+1] = max;
int number = array[start];
array[start] = array[posmin];
array[posmin] = number;
number = array[start+1];
array[start+1] = array[posmax];
array[posmax] = number;
start +=2;
}
}

------------------------------------------------------------
---------------------
int __bits(8)mas[20];
int __bits(8)res[20];


main(){
int start = 0;
int __bits(8)array[20];
for(int i=0;i<20;i++){
array[i] = mas[i];
}
while(start != 20){
int min = array[start];
int max= array[start];
int posmin = 0;
int posmax = 0;
for(int i=start+1;i<20;i++){
if(array[i]<min){
min = mas[i];
posmin = i;
}
if(array[i]>max){
max = mas[i];
posmax = i;
}
}
res[start] = min;
res[start+1] = max;
int number = array[start];
array[start] = array[posmin];
array[posmin] = number;
number = array[start+1];
array[start+1] = array[posmax];
array[posmax] = number;
start +=2;
}
}

------------------------------------------------------------
---------------------
int __bits(8)mas[20];
int __bits(8)res[20];


main(){
int start = 0;
while(start != 20){
int min = mas[start];
int max= mas[start];
for(int i=start+1;i<20;i++){
if(mas[i]<min){
min = mas[i];
}
if(mas[i]>max){
max = mas[i];
}
}
res[start] = min;
res[start+1] = max;
int j =0;
int __bits(8)array[20-start];
for(int i=0;i<20-start;i++){
if(mas[i]!=min || mas[i]!=max)
array[j++];
}
start +=2;

}
}

------------------------------------------------------------
---------------------
int __bits(8)mas[20];
int __bits(8)res[20];


main(){
int start = 0;
while(start != 20){
int min = mas[start];
int max= mas[start];
for(int i=start+1;i<20;i++){
if(mas[i]<min){
min = mas[i];
}
if(mas[i]>max){
max = mas[i];
}
}
res[start] = min;
res[start+1] = max;
start +=2;
}
}

------------------------------------------------------------
---------------------
int __bits(8) mas[20];
int __bits(8) res[20];

void main(){
int __bits(8) res1[20];
int __bits(8) res2[20];

for(int i = 0; i < 20; i++){
res1[i] = mas[i];
res2[i] = mas[i];
}

int temp;
for(i = 0; i < 20; i++)
for(int j = i; j < 20; j++)
if(res1[i] > res1[j]){
temp = res1[i];
res1[i] = res1[j];
res1[j] = temp;
}

for(i = 0; i < 20; i++)
for(j = i; j < 20; j++)
if(res2[i] < res2[j]){
temp = res2[i];
res2[i] = res2[j];
res2[j] = temp;
}

j = 0;
int k = 0;
for(i = 0; i < 20; i++)
if(i&1 == 0){
res[i] = res1[j];
j++;
}
else{
res[i] = res2[k];
k++;
}

}